//#include "StdAfx.h"
#include "ipcall.h"

CIpCall::CIpCall(void)
{
}
CIpCall::~CIpCall(void)
{
}
//int CIpCall::create()
//{
//	static pjsip_inv_session* g_inv = new pjsip_inv_session;
//
//	static pjsip_module mod_simpleua =
//	{
//		NULL, NULL,							// prev, next.	
//		{ "mod-simpleua", 12 },				// Name	
//		-1,									// Id		
//		PJSIP_MOD_PRIORITY_APPLICATION,		// Priority		
//		NULL,								// load()			
//		NULL,								// start()			
//		NULL,								// stop()		
//		NULL,								// unload()			
//		&on_rx_request,						// on_rx_request()		
//		NULL,								// on_rx_response()	
//		NULL,								// on_tx_request.		
//		NULL,								// on_tx_response()		
//		NULL,								// on_tsx_state()		
//	};
//
//	// ******************************************************************************************************************
//	// Must init PJLIB first
//	// ******************************************************************************************************************
//    status = pj_init();
//    PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
//
//	// ******************************************************************************************************************
//	// Then init PJLIB-UTIL
//	// ******************************************************************************************************************
//    status = pjlib_util_init();
//    PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
//
//	// ******************************************************************************************************************
//	// Must create a pool factory before we can allocate any memory
//	// ******************************************************************************************************************
//    pj_caching_pool_init(&cp, &pj_pool_factory_default_policy, 0);
//
//	// ******************************************************************************************************************
//	// Create global endpoint
//	// ******************************************************************************************************************
//    {
//	const pj_str_t *hostname;
//	const char *endpt_name;
//
//	// ******************************************************************************************************************
//	// Endpoint MUST be assigned a globally unique name. The name will be used as the hostname in Warning header.
//	// For this implementation, we'll use hostname for simplicity.
//	// ******************************************************************************************************************
//	hostname = pj_gethostname();
//	endpt_name = hostname->ptr;
//
//	// ******************************************************************************************************************
//	// Create the endpoint
//	// ******************************************************************************************************************
//	status = pjsip_endpt_create(&cp.factory, endpt_name, &g_endpt);
//	PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
//    }
//
//	// ******************************************************************************************************************
//	// Add UDP transport, with hard-coded port. Alternatively, application can use pjsip_udp_transport_attach() to
//    // start UDP transport, if it already has an UDP socket (e.g. after it resolves the address with STUN).
//	// ******************************************************************************************************************
//    {
//	pj_sockaddr addr;
//
//	pj_sockaddr_init(AF, &addr, NULL, (pj_uint16_t)SIP_PORT);
//	
//	if (AF == pj_AF_INET()) {
//	    status = pjsip_udp_transport_start( g_endpt, &addr.ipv4, NULL, 
//						1, NULL);
//	} else if (AF == pj_AF_INET6()) {
//	    status = pjsip_udp_transport_start6(g_endpt, &addr.ipv6, NULL,
//						1, NULL);
//	} else {
//	    status = PJ_EAFNOTSUP;
//	}
//
//	if (status != PJ_SUCCESS) {
//	    app_perror(THIS_FILE, "Unable to start UDP transport", status);
//	    return 1;
//	}
//    }
//
//	// ******************************************************************************************************************
//	// Init transaction layer. This will create/initialize transaction hash tables etc.
//	// ******************************************************************************************************************
//    status = pjsip_tsx_layer_init_module(g_endpt);
//    PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
//	
//	// ******************************************************************************************************************
//    // Initialize UA layer module. This will create/initialize dialog hash tables etc.
//	// ******************************************************************************************************************
//    status = pjsip_ua_init_module( g_endpt, NULL );
//    PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
//
//
//   	// ******************************************************************************************************************
//    // Init invite session module. The invite session module initialization takes additional argument,
//    // i.e. a structure containing callbacks to be called on specific occurence of events.
//    // The on_state_changed and on_new_session callbacks are mandatory. Application must supply the callback function.
//    // We use on_media_update() callback in this application to start media transmission.
//    // ******************************************************************************************************************
//    {
//	pjsip_inv_callback inv_cb;
//
//	// ******************************************************************************************************************
//    // Init the callback for INVITE session
//	// ******************************************************************************************************************
//	pj_bzero(&inv_cb, sizeof(inv_cb));
//	inv_cb.on_state_changed = &call_on_state_changed;
//	inv_cb.on_new_session = &call_on_forked;
//	inv_cb.on_media_update = &call_on_media_update;
//
//	// ******************************************************************************************************************
//    // Initialize invite session module
//	// ******************************************************************************************************************
//	status = pjsip_inv_usage_init(g_endpt, &inv_cb);
//	PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
//    }
//
//	// ******************************************************************************************************************
//    // Initialize 100rel support
//	// ******************************************************************************************************************
//    status = pjsip_100rel_init_module(g_endpt);
//    PJ_ASSERT_RETURN(status == PJ_SUCCESS, status);
//
//	// ******************************************************************************************************************
//    // Register our module to receive incoming requests.
//	// ******************************************************************************************************************
//    status = pjsip_endpt_register_module( g_endpt, &mod_simpleua);
//    PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
//
//
//	// ******************************************************************************************************************
//    // Initialize media endpoint. This will implicitly initialize PJMEDIA too.
//	// ******************************************************************************************************************
//#if PJ_HAS_THREADS
//    status = pjmedia_endpt_create(&cp.factory, NULL, 1, &g_med_endpt);
//#else
//    status = pjmedia_endpt_create(&cp.factory, 
//				  pjsip_endpt_get_ioqueue(g_endpt), 
//				  0, &g_med_endpt);
//#endif
//    PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
//
//	// ******************************************************************************************************************
//    // Add PCMA/PCMU codec to the media endpoint. 
//	// ******************************************************************************************************************
//#if defined(PJMEDIA_HAS_G711_CODEC) && PJMEDIA_HAS_G711_CODEC!=0
//    status = pjmedia_codec_g711_init(g_med_endpt);
//    PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
//#endif
//
//	// ******************************************************************************************************************
//    // Create media transport used to send/receive RTP/RTCP socket. One media transport is needed for each call.
//	// Application may opt to re-use the same media transport for subsequent calls.
//	// ******************************************************************************************************************
//    status = pjmedia_transport_udp_create3(g_med_endpt, AF, NULL, NULL, 
//				           RTP_PORT, 0, &g_med_transport);
//    if (status != PJ_SUCCESS) {
//	app_perror(THIS_FILE, "Unable to create media transport", status);
//	return 1;
//    }
//
//	// ******************************************************************************************************************
//    // Get socket info (address, port) of the media transport. We will need this info to create SDP (i.e. the address and
//	// port info in the SDP).
//	// ******************************************************************************************************************
//    pjmedia_transport_info_init(&g_med_tpinfo);
//    pjmedia_transport_get_info(g_med_transport, &g_med_tpinfo);
//
//}
//int CIpCall::makeCall(QString url)
//{
//	// ******************************************************************************************************************
//	// convert the type QString to Char[] for value "url"
//	// ******************************************************************************************************************
//	QByteArray tempUrl = url.toLocal8Bit();
//	char* charUrl = tempUrl.data();
//
//	// ******************************************************************************************************************
//	// ??????????????????????????????????????????????????????
//	// ******************************************************************************************************************
//	pj_sockaddr hostaddr;
//	char hostip[PJ_INET6_ADDRSTRLEN+2];
//	char temp[80];
//	pj_str_t dst_uri = pj_str(charUrl);
//	pj_str_t local_uri;
//	pjsip_dialog *dlg;
//	pjmedia_sdp_session *local_sdp;
//	pjsip_tx_data *tdata;
//
//	if (pj_gethostip(AF, &hostaddr) != PJ_SUCCESS) {
//	    app_perror(THIS_FILE, "Unable to retrieve local host IP", status);
//	    return 1;
//	}
//	pj_sockaddr_print(&hostaddr, hostip, sizeof(hostip), 2);
//
//	pj_ansi_sprintf(temp, "<sip:simpleuac@%s:%d>", 
//			hostip, SIP_PORT);
//	local_uri = pj_str(temp);
//
//	// ******************************************************************************************************************
//	// Create UAC dialog
//	// ******************************************************************************************************************
//	status = pjsip_dlg_create_uac( pjsip_ua_instance(), 
//				       &local_uri,						// local URI 
//				       &local_uri,						// local Contact
//				       &dst_uri,						// remote URI
//				       &dst_uri,						// remote target
//				       &dlg);							// dialog
//	if (status != PJ_SUCCESS) {
//	    app_perror(THIS_FILE, "Unable to create UAC dialog", status);
//	    return 1;
//	}
//
//	// ******************************************************************************************************************
//	// Get the SDP body to be put in the outgoing INVITE, by asking media endpoint to create one for us.
//	// The SDP will contain all codecs that have been registered to it (in this case, only PCMA and PCMU),
//	// plus telephony event.
//	// ******************************************************************************************************************
//	status = pjmedia_endpt_create_sdp( g_med_endpt,	    // the media endpt
//					   dlg->pool,						// pool
//					   1,								// # of streams
//					   &g_med_tpinfo.sock_info,			// RTP sock info
//					   &local_sdp);						// the SDP result
//	PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
//
//	// ******************************************************************************************************************
//	// Create the INVITE session, and pass the SDP returned earlier
//	// as the session's initial capability.
//	// ******************************************************************************************************************
//	status = pjsip_inv_create_uac( dlg, local_sdp, 0, &g_inv); 
//	PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);				   
//	
//	// ******************************************************************************************************************
//	// Create initial INVITE request. This INVITE request will contain a perfectly good request and 
//	// an SDP body as well.
//	// ******************************************************************************************************************
//	status = pjsip_inv_invite(g_inv, &tdata); 	
//	PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);	
//
//	// ******************************************************************************************************************
//	// Send initial INVITE request. From now on, the invite session's state 
//	// will be reported to us via the invite session callbacks.
//	// ******************************************************************************************************************
//	status = pjsip_inv_send_msg(g_inv, tdata); 
//	PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
//}
//int CIpCall::callObserver()
//
//{
//	pj_bool_t on_rx_request(pjsip_rx_data *rdata);
//}
//pj_bool_t CIpCall::on_rx_request(pjsip_rx_data *rdata)
//	{
//	// ******************************************************************************************************************
//	// Callback when incoming requests outside any transactions and any
//	// dialogs are received. We're only interested to hande incoming INVITE
//	// request, and we'll reject any other requests with 500 response.
//	// ******************************************************************************************************************
//		pj_sockaddr hostaddr;
//		char temp[80], hostip[PJ_INET6_ADDRSTRLEN];
//		pj_str_t local_uri;
//		pjsip_dialog *dlg;
//		pjmedia_sdp_session *local_sdp;
//		pjsip_tx_data *tdata;
//		unsigned options = 0;
//		pj_status_t status;
//
//
//	// ******************************************************************************************************************
//    // Respond (statelessly) any non-INVITE requests with 500 
//	// ******************************************************************************************************************
//		if (rdata->msg_info.msg->line.req.method.id != PJSIP_INVITE_METHOD) 
//		{
//
//			if (rdata->msg_info.msg->line.req.method.id != PJSIP_ACK_METHOD)
//			{
//				pj_str_t reason = pj_str("Simple UA unable to handle "
//				     "this request");
//
//				pjsip_endpt_respond_stateless(g_endpt, rdata, 
//					   500, &reason,
//					   NULL, NULL);
//			}
//			return PJ_TRUE;
//		}
//
//
//    /*
//     * Reject INVITE if we already have an INVITE session in progress.
//     */
//    if (g_inv) {
//
//	pj_str_t reason = pj_str("Another call is in progress");
//
//	pjsip_endpt_respond_stateless(g_endpt, rdata, 
//				       500, &reason,
//				       NULL, NULL);
//	return PJ_TRUE;
//
//    }
//
//    /* Verify that we can handle the request. */
//    status = pjsip_inv_verify_request(rdata, &options, NULL, NULL,
//				      g_endpt, NULL);
//    if (status != PJ_SUCCESS) {
//
//	pj_str_t reason = pj_str("Sorry Simple UA can not handle this INVITE");
//
//	pjsip_endpt_respond_stateless( g_endpt, rdata, 
//				       500, &reason,
//				       NULL, NULL);
//	return PJ_TRUE;
//    } 
//
//    /*
//     * Generate Contact URI
//     */
//    if (pj_gethostip(AF, &hostaddr) != PJ_SUCCESS) {
//	app_perror(THIS_FILE, "Unable to retrieve local host IP", status);
//	return PJ_TRUE;
//    }
//    pj_sockaddr_print(&hostaddr, hostip, sizeof(hostip), 2);
//
//    pj_ansi_sprintf(temp, "<sip:simpleuas@%s:%d>", 
//		    hostip, SIP_PORT);
//    local_uri = pj_str(temp);
//
//    /*
//     * Create UAS dialog.
//     */
//    status = pjsip_dlg_create_uas(pjsip_ua_instance(), 
//				   rdata,
//				   &local_uri, /* contact */
//				   &dlg);
//    if (status != PJ_SUCCESS) {
//	pjsip_endpt_respond_stateless(g_endpt, rdata, 500, NULL,
//				      NULL, NULL);
//	return PJ_TRUE;
//    }
//
//    /* 
//     * Get media capability from media endpoint: 
//     */
//
//    status = pjmedia_endpt_create_sdp(g_med_endpt, rdata->tp_info.pool, 1,
//				       &g_med_tpinfo.sock_info, 
//				       &local_sdp);
//    PJ_ASSERT_RETURN(status == PJ_SUCCESS, PJ_TRUE);
//
//
//    /* 
//     * Create invite session, and pass both the UAS dialog and the SDP
//     * capability to the session.
//     */
//    status = pjsip_inv_create_uas(dlg, rdata, local_sdp, 0, &g_inv);
//    PJ_ASSERT_RETURN(status == PJ_SUCCESS, PJ_TRUE);
//
//
//    /*
//     * Initially send 180 response.
//     *
//     * The very first response to an INVITE must be created with
//     * pjsip_inv_initial_answer(). Subsequent responses to the same
//     * transaction MUST use pjsip_inv_answer().
//     */
//    status = pjsip_inv_initial_answer(g_inv, rdata, 
//				      180, 
//				      NULL, NULL, &tdata);
//    PJ_ASSERT_RETURN(status == PJ_SUCCESS, PJ_TRUE);
//
//
//    /* Send the 180 response. */  
//    status = pjsip_inv_send_msg(g_inv, tdata); 
//    PJ_ASSERT_RETURN(status == PJ_SUCCESS, PJ_TRUE);
//
//
//    /*
//     * Now create 200 response.
//     */
//    status = pjsip_inv_answer(g_inv, 
//			       200, NULL,	/* st_code and st_text */
//			       NULL,		/* SDP already specified */
//			       &tdata);
//    PJ_ASSERT_RETURN(status == PJ_SUCCESS, PJ_TRUE);
//
//    /*
//     * Send the 200 response.
//     */
//    status = pjsip_inv_send_msg(g_inv, tdata);
//    PJ_ASSERT_RETURN(status == PJ_SUCCESS, PJ_TRUE);
//
//
//    /* Done. 
//     * When the call is disconnected, it will be reported via the callback.
//     */
//
//    return PJ_TRUE;
//}
